package com.igirl.common.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

/**
 * Redis的工具类
 * @author Henry
 *
 */
@Service
public class RedisService {

	 // 定义集群连接池
	@Autowired(required=false)
    private ShardedJedisPool shardedJedisPool;
	
	
	private <T> T execute(Function<T,ShardedJedis> fun){
		   ShardedJedis shardedJedis = null;
	        try {
	            // 从连接池中获取到jedis分片对象
	            shardedJedis = shardedJedisPool.getResource();
	            // 从redis中获取数据
	           return fun.callback(shardedJedis);
	        } finally {
	            if (null != shardedJedis) {
	                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
	                shardedJedis.close();
	            }
	        }
	}
	
	public String get(final String key){
		return this.execute(new Function<String, ShardedJedis>() {
			@Override
			public String callback(ShardedJedis e) {
				return e.get(key);
			}
		});
	}
	
	public String set(final String key,final String value){
		return this.execute(new Function<String, ShardedJedis>() {
			@Override
			public String callback(ShardedJedis e) {
				return e.set(key,value);
			}
		});
	}
	/**
	 * get key
	 * @param key
	 * @return
	 */
//	public String get(String key){
//        ShardedJedis shardedJedis = null;
//        try {
//            // 从连接池中获取到jedis分片对象
//            shardedJedis = shardedJedisPool.getResource();
//            // 从redis中获取数据
//           return shardedJedis.get(key);
//        } finally {
//            if (null != shardedJedis) {
//                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
//                shardedJedis.close();
//            }
//        }
//	}
	/**
	 * set key value
	 * @param key
	 * @param value
	 * @return
	 */
//	public String set(String key,String value){
//        ShardedJedis shardedJedis = null;
//        try {
//            // 从连接池中获取到jedis分片对象
//            shardedJedis = shardedJedisPool.getResource();
//            // 从redis中获取数据
//           return shardedJedis.set(key,value);
//        }finally {
//            if (null != shardedJedis) {
//                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
//                shardedJedis.close();
//            }
//        }
//	}
//	
	
	/**
	* 删除key
	*
	* @Author: jiaheng
	* @Date: 20:08 2018/1/3
	* @Params: [key]
	* @Return: java.lang.Long
	*/
	public Long del(String key){
        ShardedJedis shardedJedis = null;
        try {
            // 从连接池中获取到jedis分片对象
            shardedJedis = shardedJedisPool.getResource();
            // 从redis中获取数据
           return shardedJedis.del(key);
        }finally {
            if (null != shardedJedis) {
                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
                shardedJedis.close();
            }
        }
	}
	
	/**
	 * 设置生存时间
	 * @param key
	 * @param seconds 单位/秒
	 * @return
	 */
	public Long expire(String key,Integer seconds){
        ShardedJedis shardedJedis = null;
        try {
            // 从连接池中获取到jedis分片对象
            shardedJedis = shardedJedisPool.getResource();
            // 从redis中获取数据
           return shardedJedis.expire(key, seconds);
        }finally {
            if (null != shardedJedis) {
                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
                shardedJedis.close();
            }
        }
	}
	
	/**
	 * 设置key value 并设置生存时间 seconds
	 * @param key
	 * @param value
	 * @param seconds 生存时间  : 单位/秒
	 * @return
	 */
	public String setex(String key,String value,Integer seconds){
        ShardedJedis shardedJedis = null;
        try {
            // 从连接池中获取到jedis分片对象
            shardedJedis = shardedJedisPool.getResource();
            // 从redis中获取数据
           return shardedJedis.setex(key, seconds, value);
        } finally {
            if (null != shardedJedis) {
                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
                shardedJedis.close();
            }
        }
	}
}
